home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 06 - 1990 / 06.09 Sep 90 / LSObjectShell / StdWindows.p < prev   
Encoding:
Text File  |  1989-10-15  |  17.5 KB  |  742 lines  |  [TEXT/PJMM]
  1. UNIT StdWindows;
  2. {***********************************}
  3. INTERFACE
  4.  
  5.     USES
  6.         MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, MacPrint, ObjIntf, GlobalStuff, StdScroll, MyDocuments;
  7.  
  8.     TYPE
  9.         TWindow = OBJECT(TObject)
  10.                 fWKind: Integer;
  11.                 fWPtr: WindowPtr;
  12.                 fControlRgn: RgnHandle;
  13.                 fDisplayRgn: RgnHandle;
  14.                 oDocument: TDocument;
  15.                 FUNCTION ControlRgn: RgnHandle;
  16.                 FUNCTION DisplayRgn (vCtlRgn: RgnHandle): RgnHandle;
  17.                 PROCEDURE Initialize;
  18.                 PROCEDURE DoNew (vDocType: OSType);
  19.                 PROCEDURE DoOpen (vFileName: Str255;
  20.                                             vVolNum: Integer);
  21.                 FUNCTION Saved (vSaveAs: BOOLEAN): BOOLEAN;
  22.                 PROCEDURE DoClose;
  23.                 PROCEDURE DoPrint;
  24.                 PROCEDURE ApplTask;
  25.                 PROCEDURE ReDrawContent;
  26.                 PROCEDURE Grow;
  27.                 PROCEDURE Zoom (vPart: Integer);
  28.                 PROCEDURE ClickInContent (vPt: Point);
  29.                 PROCEDURE ClickInWindow (vPart: Integer);
  30.                 PROCEDURE KeyPress (vChar: CHAR);
  31.                 PROCEDURE Update;
  32.                 PROCEDURE Activate;
  33.                 PROCEDURE Edit (vItem: Integer);
  34.                 PROCEDURE Free;
  35.                 override;
  36.             END;
  37.  
  38.         TGrowWindow = OBJECT(TWindow)
  39.                 FUNCTION ControlRgn: RgnHandle;
  40.                 override;
  41.                 PROCEDURE Initialize;
  42.                 override;
  43.                 PROCEDURE Grow;
  44.                 override;
  45.                 PROCEDURE Activate;
  46.                 override;
  47.             END;
  48.  
  49.         TScrollWindow = OBJECT(TGrowWindow)
  50.                 oVBar: TScrollBar;
  51.                 oHBar: TScrollBar;
  52.                 FUNCTION ControlRgn: RgnHandle;
  53.                 override;
  54.                 PROCEDURE DoNew (vDocType: OSType);
  55.                 override;
  56.                 PROCEDURE DoOpen (vFileName: Str255;
  57.                                             vVolNum: Integer);
  58.                 override;
  59.                 PROCEDURE ReDrawContent;
  60.                 override;
  61.                 PROCEDURE ClickInContent (vPt: Point);
  62.                 override;
  63.                 PROCEDURE KeyPress (vChar: CHAR);
  64.                 override;
  65.                 PROCEDURE Activate;
  66.                 override;
  67.                 PROCEDURE Edit (vItem: Integer);
  68.                 override;
  69.                 PROCEDURE Free;
  70.                 override;
  71.             END;
  72.  
  73.         TScrollZoomWindow = OBJECT(TScrollWindow)
  74.                 PROCEDURE Initialize;
  75.                 override;
  76.                 PROCEDURE Zoom (vPart: Integer);
  77.                 override;
  78.             END;
  79.  
  80.     VAR
  81.         oWindow: TWindow;
  82.  
  83.     FUNCTION DuplicateFileName (vWPtr: WindowPtr;
  84.                                     vFileName: Str255;
  85.                                     VAR vNextWindow: WindowPeek): BOOLEAN;
  86.  
  87. {***********************************}
  88. IMPLEMENTATION
  89.  
  90.     VAR
  91.         uNr: Str255;
  92.         uRect: Rect;
  93.         uTitle: Str255;
  94.         uVisible: BOOLEAN;
  95.         uWindID: Integer;
  96.         uGoAway: BOOLEAN;
  97.         uRefVal: longint;
  98.  
  99. {========================================}
  100.     FUNCTION DuplicateFileName (vWPtr: WindowPtr;
  101.                                     vFileName: Str255;
  102.                                     VAR vNextWindow: WindowPeek): BOOLEAN;
  103.     BEGIN
  104.         DuplicateFileName := FALSE;
  105.         vNextWindow := WindowPeek(vWPtr);
  106.         REPEAT
  107.             uTitle := vNextWindow^.titleHandle^^;
  108.             IF vFileName = uTitle THEN
  109.                 BEGIN
  110.                     DuplicateFileName := TRUE;
  111.                     leave;
  112.                 END;
  113.             vNextWindow := vNextWindow^.nextWindow;
  114.         UNTIL (vNextWindow = NIL);
  115.     END;    {DuplicateFileName}
  116.  
  117. {========================================}
  118.     FUNCTION TWindow.ControlRgn: RgnHandle;
  119.         VAR
  120.             vRgn: RgnHandle;
  121.  
  122.     BEGIN
  123.         vRgn := NewRgn;
  124.         SetEmptyRgn(vRgn);
  125.         ControlRgn := vRgn;
  126.     END;    {ControlRgn}
  127.  
  128. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  129.     FUNCTION TWindow.DisplayRgn (vCtlRgn: RgnHandle): RgnHandle;
  130.         VAR
  131.             vRgn: RgnHandle;
  132.  
  133.     BEGIN
  134.         uRect := fWPtr^.portRect;
  135.         vRgn := NewRgn;
  136.         RectRgn(vRgn, uRect);
  137.         DiffRgn(vRgn, vCtlRgn, vRgn);
  138.         DisplayRgn := vRgn;
  139.     END;    {DisplayRgn}
  140.  
  141. {----------------------------------------}
  142.     PROCEDURE TWindow.Initialize;
  143.     BEGIN
  144.         GetIndString(uTitle, kStrListID, 1);
  145.         uTitle := Concat(uTitle, uNr);
  146.         uVisible := FALSE;
  147.         uWindID := noGrowDocProc;
  148.         uGoAway := TRUE;
  149.         uRefVal := 0;
  150.     END; {Initialize}
  151.  
  152. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  153.     FUNCTION NewRect (vCount: Integer): Rect;
  154.         VAR
  155.             vOffset: Integer;
  156.  
  157.     BEGIN
  158.         vOffset := (vCount - 1) * kWOffset;
  159.         IF gMinWidth > gMinHeight THEN
  160.             vOffset := vOffset MOD (gMinWidth - kWOffset)
  161.         ELSE
  162.             vOffset := vOffset MOD (gMinHeight - 2 * kWOffset);
  163.  
  164.         WITH ScreenBits.Bounds DO
  165.             BEGIN
  166.                 NewRect.left := kScreenMargin + vOffset;
  167.                 NewRect.top := 2 * gMBarHeight + vOffset;
  168.                 NewRect.right := right - kScreenMargin - gMinWidth + vOffset;
  169.                 NewRect.bottom := bottom - kScreenMargin - gMinHeight + vOffset;
  170.             END;
  171.     END;    {NewRect}
  172.  
  173. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  174.     PROCEDURE TWindow.DoNew (vDocType: OSType);
  175.     BEGIN
  176.         gWCount := gWCount + 1;
  177.         uRect := NewRect(gWCount);
  178.         NumToString(gWCount, uNr);
  179.         self.Initialize;
  180.         fWPtr := NewWindow(NIL, uRect, uTitle, uVisible, uWindID, POINTER(-1), uGoAway, uRefVal);
  181.         IF (fWPtr = NIL) THEN
  182.             Exit(DoNew);
  183.         SetWRefCon(fWPtr, Ord4(self));
  184.         SetPort(fWPtr);
  185.         fControlRgn := self.ControlRgn;
  186.         fDisplayRgn := self.DisplayRgn(fControlRgn);
  187.         IF vDocType = kTextDoc THEN
  188.             New(TTextDocument(oDocument))
  189.         ELSE IF vDocType = kPictDoc THEN
  190.             New(TPictDocument(oDocument))
  191.         ELSE
  192.             ;    {Initialize your own type of document}
  193.         WITH oDocument DO
  194.             BEGIN
  195.                 fViewRgn := self.fDisplayRgn;
  196.                 fViewRect := self.fDisplayRgn^^.rgnBBox;
  197.                 fDocType := vDocType;
  198.                 DoNew;
  199.             END;
  200.     END; {DoNew}
  201.  
  202. {----------------------------------------}
  203.     PROCEDURE TWindow.DoOpen (vFileName: Str255;
  204.                                     vVolNum: Integer);
  205.         VAR
  206.             vFileNum: Integer;
  207.  
  208.     BEGIN
  209.         IF OSError(FSOpen(vFileName, vVolNum, vFileNum)) THEN
  210.             Exit(DoOpen);
  211.         SetCursor(gWatch);
  212.         oDocument.DoOpen(vVolNum, vFileNum);
  213.         SetCursor(arrow);
  214.         IF oDocument.fFileNum <> 0 THEN
  215.             BEGIN
  216.                 SetWTitle(fWPtr, vFileName);
  217.                 InvalRgn(fDisplayRgn);
  218.             END;
  219.         IF OSError(FSClose(vFileNum)) THEN
  220.     END; {DoOpen}
  221.  
  222. {----------------------------------------}
  223.     FUNCTION TWindow.Saved (vSaveAs: BOOLEAN): BOOLEAN;
  224.         VAR
  225.             vNewFile: BOOLEAN;
  226.             vPt: Point;
  227.             vText: Str255;
  228.             vReply: SFReply;
  229.             vErr: OSErr;
  230.             vFInfo: FInfo;
  231.             vFileNum: Integer;
  232.             vVolNum: Integer;
  233.             vType: OSType;
  234.             vWPeek: WindowPeek;
  235.             vOldWPtr: WindowPtr;
  236.             oOldDoc: TDocument;
  237.  
  238.     BEGIN
  239.         Saved := FALSE;
  240.         GetWTitle(fWPtr, uTitle);
  241.         vNewFile := (oDocument.fFileNum = 0);
  242.         IF vSaveAs OR vNewFile THEN
  243.             BEGIN
  244.                 CenterDialogBox(304, 184, vPt);
  245.                 GetIndString(vText, kStrListID, 2);
  246.                 SFPutFile(vPt, vText, uTitle, NIL, vReply);
  247.                 WITH vReply DO
  248.                     IF good THEN
  249.                         BEGIN
  250.                             vErr := GetFInfo(fName, vRefNum, vFInfo);
  251.                             IF DuplicateFileName(fWPtr, fName, vWPeek) THEN
  252.                                 BEGIN
  253.                                     self.Initialize;
  254.                                     vOldWPtr := WindowPtr(vWPeek);
  255.                                     SetWTitle(vOldWPtr, uTitle);
  256.                                     oOldDoc := TWindow(GetWRefCon(vOldWPtr)).oDocument;
  257.                                     vVolNum := oOldDoc.fVolNum;
  258.                                     IF oOldDoc.fFileNum <> 0 THEN
  259.                                         IF OSError(FSDelete(fName, vVolNum)) THEN
  260.                                             Exit(Saved);
  261.                                     oOldDoc.fFileNum := 0;
  262.                                     oOldDoc.fChanged := TRUE;
  263.                                     vErr := GetFInfo(fName, vRefNum, vFInfo);
  264.                                 END;
  265.                             CASE vErr OF
  266.                                 noErr: 
  267.                                     ;
  268.                                 fnfErr: 
  269.                                     BEGIN
  270.                                         vType := oDocument.fDocType;
  271.                                         IF OSError(Create(fName, vRefNum, kCreator, vType)) THEN
  272.                                             Exit(Saved);
  273.                                     END;
  274.                                 OTHERWISE
  275.                                     IF OSError(vErr) THEN
  276.                                         Exit(Saved);
  277.                             END;
  278.                             uTitle := fName;
  279.                             SetWTitle(fWPtr, uTitle);
  280.                             oDocument.fVolNum := vRefNum;
  281.                         END
  282.                     ELSE
  283.                         Exit(Saved);
  284.             END;
  285.         IF OSError(FSOpen(uTitle, oDocument.fVolNum, vFileNum)) THEN
  286.             Exit(Saved);
  287.         SetCursor(gWatch);
  288.         oDocument.DoSave(vFileNum);
  289.         SetCursor(arrow);
  290.         IF OSError(FSClose(vFileNum)) THEN
  291.             Exit(Saved);
  292.         IF OSError(FlushVol(NIL, oDocument.fVolNum)) THEN
  293.             Exit(Saved);
  294.         Saved := TRUE;
  295.     END; {Saved}
  296.  
  297. {----------------------------------------}
  298.     PROCEDURE TWindow.DoClose;
  299.         VAR
  300.             vNextWindow: WindowPeek;
  301.  
  302.     BEGIN
  303.         IF oDocument.fChanged THEN
  304.             BEGIN
  305.                 GetWTitle(fWPtr, uTitle);
  306.                 ParamText(uTitle, '', '', '');
  307.                 CenterMyDialog('ALRT', kSaveID);
  308.                 CASE Alert(kSaveID, NIL) OF
  309.                     OK: 
  310.                         IF NOT self.Saved(FALSE) THEN
  311.                             Exit(DoClose);
  312.                     cancel: 
  313.                         BEGIN
  314.                             gQuitting := FALSE;
  315.                             Exit(DoClose);
  316.                         END;
  317.                     OTHERWISE
  318.                 END;
  319.             END;
  320.         vNextWindow := WindowPeek(FrontWindow)^.nextWindow;
  321.         IF (gWCount = 1) OR (vNextWindow^.windowkind <> userkind) THEN
  322.             gCloseFlag := TRUE;
  323.         gWCount := gWCount - 1;
  324.         self.Free;
  325.     END; {DoClose}
  326.  
  327. {----------------------------------------}
  328.     PROCEDURE DisplayPrintDialog (VAR vDPtr: DialogPtr);
  329.         VAR
  330.             vFlag: BOOLEAN;
  331.             vDEvent: EventRecord;
  332.             vDItem: Integer;
  333.  
  334.     BEGIN
  335.         CenterMyDialog('DLOG', kPrintID);
  336.         vDPtr := GetNewDialog(kPrintID, NIL, POINTER(-1));
  337.         vFlag := GetNextEvent(updateMask, vDEvent);
  338.         vFlag := DialogSelect(vDEvent, vDPtr, vDItem);
  339.     END; {DisplayPrintDialog}
  340.  
  341. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  342.     PROCEDURE TWindow.DoPrint;
  343.         VAR
  344.             vSavePort: GrafPtr;
  345.             vPrPort: TPPrPort;
  346.             vFlag: BOOLEAN;
  347.             vPrStatus: TPrStatus;
  348.             vDPtr: DialogPtr;
  349.  
  350.     BEGIN
  351.         GetPort(vSavePort);
  352.         SetCursor(gWatch);
  353.         vPrPort := PrOpenDoc(gPrintHdl, NIL, NIL);
  354.         IF OSError(PrError) THEN
  355.             Exit(DoPrint);
  356.         DisplayPrintDialog(vDPtr);
  357.         oDocument.DoPrint(vPrPort);
  358.         PrCloseDoc(vPrPort);
  359.         vFlag := NOT OSError(PrError);
  360.         vFlag := (gPrintHdl^^.prJob.bJDocLoop = bSpoolLoop) AND vFlag;
  361.         IF vFlag THEN
  362.             BEGIN
  363.                 SetCursor(gWatch);
  364.                 PrPicFile(gPrintHdl, NIL, NIL, NIL, vPrStatus);
  365.             END;
  366.         vFlag := OSError(PrError);
  367.         DisposDialog(vDPtr);
  368.         SetPort(vSavePort);
  369.     END; {DoPrint}
  370.  
  371. {----------------------------------------}
  372.     PROCEDURE TWindow.ApplTask;
  373.     BEGIN
  374.         oDocument.ApplTask;
  375.     END; {ApplTask}
  376.  
  377. {----------------------------------------}
  378.     PROCEDURE TWindow.ReDrawContent;
  379.     BEGIN
  380.         DisposeRgn(fControlRgn);
  381.         DisposeRgn(fDisplayRgn);
  382.         fControlRgn := self.ControlRgn;
  383.         fDisplayRgn := self.DisplayRgn(fControlRgn);
  384.         WITH oDocument DO
  385.             BEGIN
  386.                 fViewRgn := self.fDisplayRgn;
  387.                 fViewRect := self.fDisplayRgn^^.rgnBBox;
  388.                 ReDraw;
  389.             END;
  390.     END; {ReDrawContent}
  391.  
  392. {----------------------------------------}
  393.     PROCEDURE TWindow.Grow;
  394.     BEGIN
  395.     END; {Grow}
  396.  
  397. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  398.     PROCEDURE TWindow.Zoom;
  399.     BEGIN
  400.     END; {Zoom}
  401.  
  402. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  403.     PROCEDURE TWindow.ClickInContent (vPt: Point);
  404.     BEGIN
  405.         GlobalToLocal(vPt);
  406.         IF PtInRgn(vPt, fDisplayRgn) THEN
  407.             oDocument.ClickInDoc(vPt);
  408.     END; {ClickInContent}
  409.  
  410. {-  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -}
  411.     PROCEDURE TWindow.ClickInWindow (vPart: Integer);
  412.         VAR
  413.             vSavePort: GrafPtr;
  414.  
  415.     BEGIN
  416.         GetPort(vSavePort);
  417.         SetPort(fWPtr);
  418.         WITH gEvent DO
  419.             CASE vPart OF
  420.                 inDrag: 
  421.                     IF fWPtr <> FrontWindow THEN
  422.                         SelectWindow(fWPtr)
  423.                     ELSE
  424.                         DragWindow(fWPtr, where, gDragRect);
  425.                 inGoAway: 
  426.                     IF TrackGoAway(fWPtr, where) THEN
  427.                         self.DoClose;
  428.                 inGrow: 
  429.                     self.Grow;
  430.                 inZoomIn, inZoomOut: 
  431.                     IF TrackBox(fWPtr, where, vPart) THEN
  432.                         self.Zoom(vPart);
  433.                 inContent: 
  434.                     IF fWPtr <> FrontWindow THEN
  435.                         SelectWindow(fWPtr)
  436.                     ELSE
  437.                         self.ClickInContent(where);
  438.                 OTHERWISE
  439.             END;
  440.         SetPort(vSavePort);
  441.     END; {ClickInWindow}
  442.  
  443. {----------------------------------------}
  444.     PROCEDURE TWindow.KeyPress (vChar: CHAR);
  445.     BEGIN
  446.         oDocument.KeyPress(vChar);
  447.     END; {KeyPress}
  448.  
  449. {----------------------------------------}
  450.     PROCEDURE TWindow.Update;
  451.         VAR
  452.             vSavePort: GrafPtr;
  453.  
  454.     BEGIN
  455.         GetPort(vSavePort);
  456.         SetPort(fWPtr);
  457.         BeginUpdate(fWPtr);
  458.         SetClip(fControlRgn);
  459.         IF fWKind <> kNoGrow THEN
  460.             DrawGrowIcon(fWPtr);
  461.         DrawControls(fWPtr);
  462.         SetClip(fDisplayRgn);
  463.         EraseRgn(fDisplayRgn);
  464.         oDocument.Update;
  465.         ClipRect(fWPtr^.portRect);
  466.         EndUpdate(fWPtr);
  467.         SetPort(vSavePort);
  468.     END; {Update}
  469.  
  470. {----------------------------------------}
  471.     PROCEDURE TWindow.Activate;
  472.     BEGIN
  473.         SetPort(fWPtr);
  474.         oDocument.Activate;
  475.     END; {Activate}
  476.  
  477. {----------------------------------------}
  478.     PROCEDURE TWindow.Edit (vItem: Integer);
  479.     BEGIN
  480.         oDocument.Edit(vItem);
  481.     END; {Edit}
  482.  
  483. {----------------------------------------}
  484.     PROCEDURE TWindow.Free;
  485.     BEGIN
  486.         oDocument.Free;
  487.         DisposeRgn(fControlRgn);
  488.         DisposeRgn(fDisplayRgn);
  489.         DisposeWindow(fWPtr);
  490.         INHERITED Free;
  491.     END; {Free}
  492.  
  493. {========================================}
  494.     FUNCTION TGrowWindow.ControlRgn: RgnHandle;
  495.         VAR
  496.             vRgn: RgnHandle;
  497.  
  498.     BEGIN
  499.         vRgn := NewRgn;
  500.         uRect := fWPtr^.portRect;
  501.         WITH uRect DO
  502.             BEGIN
  503.                 left := right - kSBarWidth;
  504.                 top := bottom - kSBarWidth;
  505.             END;
  506.         RectRgn(vRgn, uRect);
  507.  
  508.         ControlRgn := vRgn;
  509.     END;    {ControlRgn}
  510.  
  511. {----------------------------------------}
  512.     PROCEDURE TGrowWindow.Initialize;
  513.     BEGIN
  514.         GetIndString(uTitle, kStrListID, 1);
  515.         uTitle := Concat(uTitle, uNr);
  516.         uVisible := FALSE;
  517.         uWindID := documentProc;
  518.         uGoAway := TRUE;
  519.         uRefVal := 0;
  520.     END; {Initialize}
  521.  
  522. {----------------------------------------}
  523.     PROCEDURE TGrowWindow.Grow;
  524.         VAR
  525.             vNewSize: LongInt;
  526.             vWidth: Integer;
  527.             vHeight: Integer;
  528.             vHFlag, vVFlag: BOOLEAN;
  529.  
  530.     BEGIN
  531.         vNewSize := GrowWindow(fWPtr, gEvent.where, gGrowRect);
  532.         IF vNewSize <> 0 THEN
  533.             BEGIN
  534.                 vWidth := LoWord(vNewSize);
  535.                 vHeight := HiWord(vNewSize);
  536.                 WITH fWPtr^.portRect DO
  537.                     BEGIN
  538.                         vHFlag := (vWidth > (right - left));
  539.                         vVFlag := (vHeight > (bottom - top));
  540.                     END;
  541.                 IF vHFlag OR vVFlag THEN
  542.                     BEGIN
  543.                         EraseRgn(fControlRgn);
  544.                         InvalRgn(fControlRgn);
  545.                     END;
  546.                 SizeWindow(fWPtr, vWidth, vHeight, TRUE);
  547.                 self.ReDrawContent;
  548.                 IF NOT vHFlag OR NOT vVFlag THEN
  549.                     BEGIN
  550.                         EraseRgn(fControlRgn);
  551.                         InvalRgn(fControlRgn);
  552.                     END;
  553.             END;
  554.     END; {Grow}
  555.  
  556. {----------------------------------------}
  557.     PROCEDURE TGrowWindow.Activate;
  558.     BEGIN
  559.         INHERITED Activate;
  560.         SetClip(fControlRgn);
  561.         DrawGrowIcon(fWPtr);
  562.         ClipRect(fWPtr^.portRect);
  563.     END; {Activate}
  564.  
  565. {========================================}
  566.     FUNCTION TScrollWindow.ControlRgn: RgnHandle;
  567.         VAR
  568.             vRgn1, vRgn2: RgnHandle;
  569.  
  570.     BEGIN
  571.         vRgn1 := INHERITED ControlRgn;
  572.         IF fWKind IN [kHScroll, kScroll, kHScrollZoom, kScrollZoom] THEN
  573.             BEGIN
  574.                 vRgn2 := NewRgn;
  575.                 WITH fWPtr^.portRect DO
  576.                     SetRect(uRect, left, bottom - kSBarWidth, right - kSBarWidth, bottom);
  577.                 RectRgn(vRgn2, uRect);
  578.                 UnionRgn(vRgn1, vRgn2, vRgn1);
  579.                 DisposeRgn(vRgn2);
  580.             END;
  581.         IF fWKind IN [kVScroll, kScroll, kVScrollZoom, kScrollZoom] THEN
  582.             BEGIN
  583.                 vRgn2 := NewRgn;
  584.                 WITH fWPtr^.portRect DO
  585.                     SetRect(uRect, right - kSBarWidth, top, right, bottom - kSBarWidth);
  586.                 RectRgn(vRgn2, uRect);
  587.                 UnionRgn(vRgn1, vRgn2, vRgn1);
  588.                 DisposeRgn(vRgn2);
  589.             END;
  590.         ControlRgn := vRgn1;
  591.     END;    {ControlRgn}
  592.  
  593. {----------------------------------------}
  594.     PROCEDURE TScrollWindow.DoNew (vDocType: OSType);
  595.     BEGIN
  596.         INHERITED DoNew(vDocType);
  597.         oHBar := NIL;
  598.         oVBar := NIL;
  599.         IF fWKind IN [kHScroll, kScroll, kHScrollZoom, kScrollZoom] THEN
  600.             BEGIN
  601.                 New(oHBar);
  602.                 oHBar.oDocument := self.oDocument;
  603.                 WITH fWPtr^.portRect DO
  604.                     SetRect(uRect, -1 + kHBarMargin, bottom - kSBarWidth, right - kSBarWidth + 1, bottom + 1);
  605.                 oHBar.DoNew(kHBar, fWPtr, uRect);
  606.             END;
  607.         IF fWKind IN [kVScroll, kScroll, kVScrollZoom, kScrollZoom] THEN
  608.             BEGIN
  609.                 New(oVBar);
  610.                 oVBar.oDocument := self.oDocument;
  611.                 WITH fWPtr^.portRect DO
  612.                     SetRect(uRect, right - kSBarWidth, -1, right + 1, bottom - kSBarWidth + 1);
  613.                 oVBar.DoNew(kVBar, fWPtr, uRect);
  614.             END;
  615.         InitAutoScroll(oDocument);
  616.     END; {DoNew}
  617.  
  618. {----------------------------------------}
  619.     PROCEDURE TScrollWindow.DoOpen (vFileName: Str255;
  620.                                     vVolNum: Integer);
  621.     BEGIN
  622.         INHERITED DoOpen(vFileName, vVolNum);
  623.         IF oHBar <> NIL THEN
  624.             oHBar.Adjust;
  625.         IF oVBar <> NIL THEN
  626.             oVBar.Adjust;
  627.     END; {DoOpen}
  628.  
  629. {----------------------------------------}
  630.     PROCEDURE TScrollWindow.ReDrawContent;
  631.     BEGIN
  632.         INHERITED ReDrawContent;
  633.         IF oHBar <> NIL THEN
  634.             BEGIN
  635.                 WITH fWPtr^.portRect DO
  636.                     SetRect(uRect, -1 + kHBarMargin, bottom - kSBarWidth, right - kSBarWidth + 2 - kHBarMargin, kSBarWidth + 1);
  637.                 oHBar.ReDraw(uRect);
  638.             END;
  639.         IF oVBar <> NIL THEN
  640.             BEGIN
  641.                 WITH fWPtr^.portRect DO
  642.                     SetRect(uRect, right - kSBarWidth, -1, kSBarWidth + 1, bottom - kSBarWidth + 2);
  643.                 oVBar.ReDraw(uRect);
  644.             END;
  645.     END; {ReDrawContent}
  646.  
  647. {----------------------------------------}
  648.     PROCEDURE TScrollWindow.ClickInContent (vPt: Point);
  649.         VAR
  650.             vPart: Integer;
  651.             vCtlHdl: ControlHandle;
  652.  
  653.     BEGIN
  654.         GlobalToLocal(vPt);
  655.         vPart := FindControl(vPt, fWPtr, vCtlHdl);
  656.         CASE vPart OF
  657.             inUpButton..inPageDown, inThumb: 
  658.                 CASE GetCRefCon(vCtlHdl) OF
  659.                     kHBar: 
  660.                         oHBar.ClickInSBar(vPart, vPt);
  661.                     kVBar: 
  662.                         oVBar.ClickInSBar(vPart, vPt);
  663.                 END;
  664.             inButton: 
  665.                 ;
  666.             inCheckBox: 
  667.                 ;
  668.             OTHERWISE
  669.                 BEGIN
  670.                     IF oHBar <> NIL THEN
  671.                         oHBar.SetupAutoScroll(fWKind);
  672.                     IF oVBar <> NIL THEN
  673.                         oVBar.SetupAutoScroll(fWKind);
  674.                     LocalToGlobal(vPt);
  675.                     INHERITED ClickInContent(vPt);
  676.                 END;
  677.         END;
  678.     END; {ClickInContent}
  679.  
  680. {----------------------------------------}
  681.     PROCEDURE TScrollWindow.KeyPress (vChar: CHAR);
  682.     BEGIN
  683.         INHERITED KeyPress(vChar);
  684.         IF oHBar <> NIL THEN
  685.             oHBar.Adjust;
  686.         IF oVBar <> NIL THEN
  687.             oVBar.Adjust;
  688.     END; {KeyPress}
  689.  
  690. {----------------------------------------}
  691.     PROCEDURE TScrollWindow.Activate;
  692.     BEGIN
  693.         INHERITED Activate;
  694.         IF oHBar <> NIL THEN
  695.             oHBar.Activate;
  696.         IF oVBar <> NIL THEN
  697.             oVBar.Activate;
  698.     END; {Activate}
  699.  
  700. {----------------------------------------}
  701.     PROCEDURE TScrollWindow.Edit (vItem: Integer);
  702.     BEGIN
  703.         INHERITED Edit(vItem);
  704.         IF oHBar <> NIL THEN
  705.             oHBar.Adjust;
  706.         IF oVBar <> NIL THEN
  707.             oVBar.Adjust;
  708.     END; {Edit}
  709.  
  710. {----------------------------------------}
  711.     PROCEDURE TScrollWindow.Free;
  712.     BEGIN
  713.         KillControls(fWPtr);
  714.         IF oHBar <> NIL THEN
  715.             oHBar.Free;
  716.         IF oVBar <> NIL THEN
  717.             oVBar.Free;
  718.         INHERITED Free;
  719.     END; {Free}
  720.  
  721. {========================================}
  722.     PROCEDURE TScrollZoomWindow.Initialize;
  723.  
  724.     BEGIN
  725.         GetIndString(uTitle, kStrListID, 1);
  726.         uTitle := Concat(uTitle, uNr);
  727.         uVisible := FALSE;
  728.         uWindID := documentProc + kScrollZoom;
  729.         uGoAway := TRUE;
  730.         uRefVal := 0;
  731.     END; {Initialize}
  732.  
  733. {----------------------------------------}
  734.     PROCEDURE TScrollZoomWindow.Zoom (vPart: Integer);
  735.     BEGIN
  736.         EraseRect(fWPtr^.portRect);
  737.         ZoomWindow(fWPtr, vPart, TRUE);
  738.         self.ReDrawContent;
  739.     END; {Zoom}
  740.  
  741. END.    {unit StdWindows}
  742. {***********************************}